/**
 * Copyright (c) Tiny Technologies, Inc. All rights reserved.
 * Licensed under the LGPL or a commercial license.
 * For LGPL see License.txt in the project root for license information.
 * For commercial licenses see https://www.tiny.cloud/
 *
 * Version: 5.8.2 (2021-06-23)
 */
(function () {
  'use strict'

  var global = tinymce.util.Tools.resolve('tinymce.PluginManager')

  var applyListFormat = function (editor, listName, styleValue) {
    var cmd = listName === 'UL' ? 'InsertUnorderedList' : 'InsertOrderedList'
    editor.execCommand(cmd, false, styleValue === false ? null : { 'list-style-type': styleValue })
  }

  var register = function (editor) {
    editor.addCommand('ApplyUnorderedListStyle', function (ui, value) {
      applyListFormat(editor, 'UL', value['list-style-type'])
    })
    editor.addCommand('ApplyOrderedListStyle', function (ui, value) {
      applyListFormat(editor, 'OL', value['list-style-type'])
    })
  }

  var global$1 = tinymce.util.Tools.resolve('tinymce.util.Tools')

  var getNumberStyles = function (editor) {
    var styles = editor.getParam('advlist_number_styles', 'default,lower-alpha,lower-greek,lower-roman,upper-alpha,upper-roman')
    return styles ? styles.split(/[ ,]/) : []
  }
  var getBulletStyles = function (editor) {
    var styles = editor.getParam('advlist_bullet_styles', 'default,circle,square')
    return styles ? styles.split(/[ ,]/) : []
  }

  var noop = function () {
  }
  var constant = function (value) {
    return function () {
      return value
    }
  }
  var never = constant(false)
  var always = constant(true)

  var none = function () {
    return NONE
  }
  var NONE = (function () {
    var eq = function (o) {
      return o.isNone()
    }
    var call = function (thunk) {
      return thunk()
    }
    var id = function (n) {
      return n
    }
    var me = {
      fold: function (n, _s) {
        return n()
      },
      is: never,
      isSome: never,
      isNone: always,
      getOr: id,
      getOrThunk: call,
      getOrDie: function (msg) {
        throw new Error(msg || 'error: getOrDie called on none.')
      },
      getOrNull: constant(null),
      getOrUndefined: constant(undefined),
      or: id,
      orThunk: call,
      map: none,
      each: noop,
      bind: none,
      exists: never,
      forall: always,
      filter: none,
      equals: eq,
      equals_: eq,
      toArray: function () {
        return []
      },
      toString: constant('none()')
    }
    return me
  }())
  var some = function (a) {
    var constant_a = constant(a)
    var self = function () {
      return me
    }
    var bind = function (f) {
      return f(a)
    }
    var me = {
      fold: function (n, s) {
        return s(a)
      },
      is: function (v) {
        return a === v
      },
      isSome: always,
      isNone: never,
      getOr: constant_a,
      getOrThunk: constant_a,
      getOrDie: constant_a,
      getOrNull: constant_a,
      getOrUndefined: constant_a,
      or: self,
      orThunk: self,
      map: function (f) {
        return some(f(a))
      },
      each: function (f) {
        f(a)
      },
      bind: bind,
      exists: bind,
      forall: bind,
      filter: function (f) {
        return f(a) ? me : NONE
      },
      toArray: function () {
        return [a]
      },
      toString: function () {
        return 'some(' + a + ')'
      },
      equals: function (o) {
        return o.is(a)
      },
      equals_: function (o, elementEq) {
        return o.fold(never, function (b) {
          return elementEq(a, b)
        })
      }
    }
    return me
  }
  var from = function (value) {
    return value === null || value === undefined ? NONE : some(value)
  }
  var Optional = {
    some: some,
    none: none,
    from: from
  }

  var isChildOfBody = function (editor, elm) {
    return editor.$.contains(editor.getBody(), elm)
  }
  var isTableCellNode = function (node) {
    return node && /^(TH|TD)$/.test(node.nodeName)
  }
  var isListNode = function (editor) {
    return function (node) {
      return node && /^(OL|UL|DL)$/.test(node.nodeName) && isChildOfBody(editor, node)
    }
  }
  var getSelectedStyleType = function (editor) {
    var listElm = editor.dom.getParent(editor.selection.getNode(), 'ol,ul')
    var style = editor.dom.getStyle(listElm, 'listStyleType')
    return Optional.from(style)
  }

  var findIndex = function (list, predicate) {
    for (var index = 0; index < list.length; index++) {
      var element = list[index]
      if (predicate(element)) {
        return index
      }
    }
    return -1
  }
  var styleValueToText = function (styleValue) {
    return styleValue.replace(/\-/g, ' ').replace(/\b\w/g, function (chr) {
      return chr.toUpperCase()
    })
  }
  var isWithinList = function (editor, e, nodeName) {
    var tableCellIndex = findIndex(e.parents, isTableCellNode)
    var parents = tableCellIndex !== -1 ? e.parents.slice(0, tableCellIndex) : e.parents
    var lists = global$1.grep(parents, isListNode(editor))
    return lists.length > 0 && lists[0].nodeName === nodeName
  }
  var addSplitButton = function (editor, id, tooltip, cmd, nodeName, styles) {
    editor.ui.registry.addSplitButton(id, {
      tooltip: tooltip,
      icon: nodeName === 'OL' ? 'ordered-list' : 'unordered-list',
      presets: 'listpreview',
      columns: 3,
      fetch: function (callback) {
        var items = global$1.map(styles, function (styleValue) {
          var iconStyle = nodeName === 'OL' ? 'num' : 'bull'
          var iconName = styleValue === 'disc' || styleValue === 'decimal' ? 'default' : styleValue
          var itemValue = styleValue === 'default' ? '' : styleValue
          var displayText = styleValueToText(styleValue)
          return {
            type: 'choiceitem',
            value: itemValue,
            icon: 'list-' + iconStyle + '-' + iconName,
            text: displayText
          }
        })
        callback(items)
      },
      onAction: function () {
        return editor.execCommand(cmd)
      },
      onItemAction: function (_splitButtonApi, value) {
        applyListFormat(editor, nodeName, value)
      },
      select: function (value) {
        var listStyleType = getSelectedStyleType(editor)
        return listStyleType.map(function (listStyle) {
          return value === listStyle
        }).getOr(false)
      },
      onSetup: function (api) {
        var nodeChangeHandler = function (e) {
          api.setActive(isWithinList(editor, e, nodeName))
        }
        editor.on('NodeChange', nodeChangeHandler)
        return function () {
          return editor.off('NodeChange', nodeChangeHandler)
        }
      }
    })
  }
  var addButton = function (editor, id, tooltip, cmd, nodeName, _styles) {
    editor.ui.registry.addToggleButton(id, {
      active: false,
      tooltip: tooltip,
      icon: nodeName === 'OL' ? 'ordered-list' : 'unordered-list',
      onSetup: function (api) {
        var nodeChangeHandler = function (e) {
          api.setActive(isWithinList(editor, e, nodeName))
        }
        editor.on('NodeChange', nodeChangeHandler)
        return function () {
          return editor.off('NodeChange', nodeChangeHandler)
        }
      },
      onAction: function () {
        return editor.execCommand(cmd)
      }
    })
  }
  var addControl = function (editor, id, tooltip, cmd, nodeName, styles) {
    if (styles.length > 1) {
      addSplitButton(editor, id, tooltip, cmd, nodeName, styles)
    } else {
      addButton(editor, id, tooltip, cmd, nodeName)
    }
  }
  var register$1 = function (editor) {
    addControl(editor, 'numlist', 'Numbered list', 'InsertOrderedList', 'OL', getNumberStyles(editor))
    addControl(editor, 'bullist', 'Bullet list', 'InsertUnorderedList', 'UL', getBulletStyles(editor))
  }

  function Plugin () {
    global.add('advlist', function (editor) {
      if (editor.hasPlugin('lists')) {
        register$1(editor)
        register(editor)
      } else {
        console.error('Please use the Lists plugin together with the Advanced List plugin.')
      }
    })
  }

  Plugin()
}())
